<%@Page Language="C#" AutoEventWireup="true" CodeFile="Default.aspx.cs" Inherits="_Default" %>
 
<%@Import Namespace="System.Net" %>
<%@Import Namespace="System.IO" %>
<%@Import Namespace="System.Web.Script.Serialization" %>
<%@Import Namespace="System.Threading.Tasks" %>

<%        
    //--------------------------------------------------------------------
    //
    //  For this sample, the location to look for source documents 
    //  specified only by name and the PCC Imaging Services (PCCIS) URL 
    //  are configured in pcc.config.
    //
    //--------------------------------------------------------------------
 
    PccConfig.LoadConfig("pcc.config");
 
    JavaScriptSerializer serializer = new JavaScriptSerializer();
    string[] transferProtocols = { "http://", "https://", "ftp://" };
    string document = string.Empty;
    string viewingSessionId = string.Empty;
 
    string documentQueryParameter = Request.QueryString["document"];
    if (!string.IsNullOrEmpty(documentQueryParameter))
    {
        // Construct the full path to the source document
        if (transferProtocols.Any(documentQueryParameter.Contains))
        {
            document = documentQueryParameter;
        }
        else
        {
            document = Path.Combine(PccConfig.DocumentFolder, documentQueryParameter);
        }
 
        // Get the document's extension because PCCIS will need it later.
        string extension = System.IO.Path.GetExtension(document).TrimStart(new char[] { '.' }).ToLower();
 
        if (Path.IsPathRooted(document))
        {
            bool correctPath = PccConfig.IsFileSafeToOpen(document);
            if (!correctPath)
            {
                Response.Clear();
                Response.Write("<h1>403 Forbidden</h1>");
                Response.StatusCode = (int)System.Net.HttpStatusCode.Forbidden;
                return;
            }
        }
 
        // Request a new viewing session from PCCIS.
        //   POST http://localhost:18681/PCCIS/V1/ViewingSession
        // 
        string uriString = string.Format("{0}/ViewingSession", PccConfig.ImagingService);
        HttpWebRequest request = (HttpWebRequest)WebRequest.Create(uriString);
        request.Method = "POST";
        using (StreamWriter requestStream = new StreamWriter(request.GetRequestStream(), Encoding.UTF8))
        {
            ViewingSessionProperties viewingSessionProperties = new ViewingSessionProperties();
 
            // Store some information in PCCIS to be retrieved later.
            viewingSessionProperties.externalId = CommonCode.Encoder.GetHashString(document);
            viewingSessionProperties.tenantId = "My User ID";
 
            // The following are examples of arbitrary information as key-value 
            // pairs that PCCIS will associate with this document request.
            Dictionary<string, string> originInfo = new Dictionary<string, string>();
            originInfo.Add("ipAddress", Request.UserHostAddress);
            originInfo.Add("hostName", Request.UserHostName);
            originInfo.Add("sourceDocument", document);
            viewingSessionProperties.origin = originInfo;
 
            // Specify rendering properties.
            viewingSessionProperties.render = new RenderProperties() { flash = new FlashRenderProperties() { optimizationLevel = 1 }, html5 = new Html5RenderProperties { alwaysUseRaster = false } };
 
            // Serialize document properties as JSON which will go into the body of the request
            string requestBody = serializer.Serialize(viewingSessionProperties);
            requestStream.Write(requestBody);
        }
 
        HttpWebResponse response = (HttpWebResponse)request.GetResponse();
        string responseBody = null;
        using (StreamReader sr = new StreamReader(response.GetResponseStream(), System.Text.Encoding.UTF8))
        {
            responseBody = sr.ReadToEnd();
        }
 
        // Store the ID for this viewing session that is returned by PCCIS
        Dictionary<string, object> responseValues = (Dictionary<string, object>)serializer.DeserializeObject(responseBody);
        viewingSessionId = responseValues["viewingSessionId"].ToString();
 
        // Get the user agent from the Request object so we can send to PCCIS in the background thread.
        // PCCIS uses this information to determine support for SVG and logging purposes.
        string userAgent = Request.Headers["User-Agent"];
 
        // Use a background thread to send the document to PCCIS and begin a viewing session.
        // This allows the current web page to finish loading and the PCC viewer to appear sooner.
        Task notificationTask = new Task(() =>
        {
            Stream documentStream = null;
            try
            {
                // Open the source document
                if (transferProtocols.Any(document.Contains))
                {
                    // Download the source document to memory if it's a remote document. The document
                    // data will be uploaded to PCCIS soon after.
                    HttpWebRequest fileRequest = (HttpWebRequest)HttpWebRequest.Create(document);
                    HttpWebResponse fileResponse = (HttpWebResponse)fileRequest.GetResponse();
 
                    using (Stream responseStream = fileResponse.GetResponseStream())
                    {
                        documentStream = new MemoryStream();
                        responseStream.CopyTo(documentStream);
                        documentStream.Seek(0, SeekOrigin.Begin);
                    }
                }
                else
                {
                    documentStream = new FileStream(document, FileMode.Open, FileAccess.Read);
                }
 
                // Upload File to PCCIS.
                //   PUT http://localhost:18681/PCCIS/V1/ViewingSessions/u{ViewingSessionID}/SourceFile?FileExtension={FileExtension}
                // Note the "u" prefixed to the Viewing Session ID. This is required when providing
                //   an unencoded Viewing Session ID, which is what PCCIS returns from the initial POST.
                //     
                uriString = string.Format("{0}/ViewingSession/u{1}/SourceFile?FileExtension={2}", PccConfig.ImagingService, viewingSessionId, HttpUtility.UrlEncode(extension));
                request = (HttpWebRequest)WebRequest.Create(uriString);
                request.Method = "PUT";
                using (Stream requestStream = request.GetRequestStream())
                {
                    documentStream.CopyTo(requestStream);
                }
                response = (HttpWebResponse)request.GetResponse();
 
                // Start Viewing Session in PCCIS.
                //   POST http://localhost:18681/PCCIS/V1/ViewingSessions/u{ViewingSessionID}/Notification/SessionStarted
                //    
                uriString = string.Format("{0}/ViewingSession/u{1}/Notification/SessionStarted", PccConfig.ImagingService, viewingSessionId);
                request = (HttpWebRequest)WebRequest.Create(uriString);
                request.Method = "POST";
                request.UserAgent = userAgent;
                using (Stream requestStream = request.GetRequestStream())
                {
                    using (TextWriter requestStreamWriter = new StreamWriter(requestStream))
                    {
                        serializer = new JavaScriptSerializer();
 
                      // USE the Desired viewer type here!!!!
                        string requestBody = serializer.Serialize(new { viewer = "HTML5" });
                      //     OR
                        string requestBody = serializer.Serialize(new { viewer = "Flash" });
                     // 
                        requestStreamWriter.Write(requestBody);
                    }
                }
                response = (HttpWebResponse)request.GetResponse();
            }
            catch (Exception ex)
            {
                // If a problem was encountered in the background thread, notify PCCIS 
                // that the session should be stopped so it can return appropriate status
                // to the viewer requests made to it.
                //   POST http://localhost:18681/PCCIS/V1/ViewingSessions/u{ViewingSessionID}/Notification/SessionStopped
                //
                uriString = string.Format("{0}/ViewingSession/u{1}/Notification/SessionStopped", PccConfig.ImagingService, viewingSessionId);
                request = (HttpWebRequest)WebRequest.Create(uriString);
                request.Method = "POST";
                using (Stream requestStream = request.GetRequestStream())
                {
                    using (TextWriter requestStreamWriter = new StreamWriter(requestStream))
                    {
                        string requestBody = serializer.Serialize(new { endUserMessage = ex.Message, httpStatus = 504 });
                        requestStreamWriter.Write(requestBody);
                    }
                }
                response = (HttpWebResponse)request.GetResponse();
            }
            finally
            {
                if (documentStream != null)
                {
                    documentStream.Dispose();
                }
            }
        });
        notificationTask.Start();
    }
    else
    {
        viewingSessionId = Request.QueryString["viewingSessionId"];
        if (!string.IsNullOrEmpty(viewingSessionId))
        {
            // If there was no 'document' parameter, but a 'viewingSessionId'
            // value exists, there is a viewing session already so we don't 
            // need to do anything else. This case is true when viewing attachments
            // of email message document types (.EML and .MSG).
 
            // Request properties about the viewing session from PCCIS. 
            // The properties will include an identifier of the source document 
            // from which the attachment was obtained. The name of the attachment
            // is also available. These values are used to just to provide
            // contextual information to the user.
            //   GET http://localhost:18681/PCCIS/V1/ViewingSession/u{ViewingSessionID}
            //
            string uriString = string.Format("{0}/ViewingSession/u{1}", PccConfig.ImagingService, viewingSessionId);
            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(uriString);
            request.Method = "GET";
            HttpWebResponse response = (HttpWebResponse)request.GetResponse();
            string responseBody = null;
            using (StreamReader sr = new StreamReader(response.GetResponseStream(), System.Text.Encoding.UTF8))
            {
                responseBody = sr.ReadToEnd();
            }
            ViewingSessionProperties viewingSessionProperties = serializer.Deserialize<ViewingSessionProperties>(responseBody);
            document = viewingSessionProperties.origin["sourceDocument"] + ":{" + viewingSessionProperties.attachmentDisplayName + "}";
        }
        else
        {
            Response.Write("You must include the name of a document in the URL.<br/>");
            Response.Write("For example, click on this link: <a href=\"Default.aspx?document=sample.doc\">Default.aspx?document=sample.doc</a>");
            return;
        }
    }
%>